IThe use of a tuple for the coordinates seems unusual to me. The constructor takes x and y arguments. Are there other displayio things that take tuples for (x, y)?

tilegrid.contains()

I actually did try using x and y arguments at first though, and I'd be happy to get back to that. I failed at figuring out how to properly do something like MP_DEFINE_CONST_FUN_OBJ_4. I found MP_DEFINE_CONST_FUN_OBJ_VAR which seems like it should do what I needed by passing 4 for min args, but I failed to make it work and ended up switching to a tuple in order to get down to 3 arguments needed so that I could use MP_DEFINE_CONST_FUN_OBJ_3

I've got a few ideas in mind that might be able to trim some bits of code. I'll see if I can get it under the limit for the one that overflowed.

I was able to shave 30 or so bytes by refactoring the nested for loops, and the larger branching if statements. However it's still not enough to fit the feather m0 supersized.

I've disabled rainbowio on that device for now which makes it match the feather m0 express.

If someone can point me towards how to use MP_DEFINE_CONST_FUN_OBJ_VAR or whatever is needed to define a function that has 4 total arguments I can try splitting x and y values back out of the tuples, perhaps losing the code that unpacks the values from tuple might get it closer to fitting, but not sure if it'll be enough, am willing to try.

If you think using the tuple is more consistent with the rest of the API, then I'd say stick with that.

There are a bunch of uses of MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN . I remember being mildly tripped up about counting the self argument or not, I think, but I don't remember the details.

okay, I'll leave it alone for now. it does also match the tile getter and setter that use square bracket access in python code like tg[(3,0)] = 24 which accept tuples as the value in the brackets and without the parens tg[3,0] = 24 which is essentially the same as I understand it.

This needs to handle dirty area inside of set_inverted. Currently the change wont become visible unless something else changes causing the area of the tile to get refreshed.

In the example script above it works because it gets set before being rendered the first time I think. But with an added time.sleep() and then changing some invert values they do not take effect currently.

The latest commit resolves that issue by forcing refresh on tiles when their inverted state changes.

This new example code validates that it behaves as expected:

import time

import board

import displayio
import terminalio

palette = displayio.Palette(2)
palette[0] = 0x000000
palette[1] = 0xffffff

bbox = terminalio.FONT.get_bounding_box()
tg = displayio.TileGrid(terminalio.FONT.bitmap, pixel_shader=palette,
                        tile_width=bbox[0], tile_height=bbox[1],
                        width=10, height=4, default_tile=0)

for i in range(40):
    tg[i] = i

main_group = displayio.Group()
main_group.append(tg)

board.DISPLAY.root_group = main_group

while True:
    for y in range(tg.height):
        for x in range(tg.width):
            cur = (x, y)
            tg.set_inverted(cur, not tg.get_inverted(cur))
            time.sleep(0.025)

This needed validation on the x,y values in order to avoid hard faulting if the user passes values outside the range of the tilegrid size. After adding those it pushed the feather_m0_supersized over the limit again.

I ended up disabling displayio on that device which leaves plenty of room. I am open to suggestion if there is something else that would be better to disable on that device.

Will make a new branch and PR for this with the TilePaletteMapper approach